home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Graphics / Viewers / pCD0.3.4 / Source / Controller.m < prev    next >
Encoding:
Text File  |  1995-06-12  |  15.4 KB  |  558 lines
  1. #import <appkit/appkit.h>
  2.  
  3. #import "Controller.h"
  4. #import "PhotoWinProcs.h"
  5. #import "ImageView.h"
  6. #import "Overviews.subproj/OV_Window.h"
  7. #import "Photo_CD.subproj/photoCD_Rdr.h"
  8.  
  9. #define IMG  0
  10. #define WIN  1    
  11.  
  12. #define TIFF 0
  13. #define EPS  1
  14. #define JPG  2
  15.  
  16. @implementation Controller
  17.  
  18. - appDidInit:sender
  19. {
  20.     int    tempInt;
  21.     char    tempStr[30];
  22.     PrintInfo  *pInfo;
  23.     enum _NXWindowDepth depthPref;
  24.     NXDefaultsVector defs =
  25.         {
  26.         {"GammaCorrection","NeXT"},
  27.         {"OpenImageSize","base"},
  28.         {"OpenImageResolution","72"},
  29.         {"OpenImageWindowDepth","24_Bit_RGB"},
  30.         {"OverviewLayout","6x7"},
  31.         {"PrintPagination","ScaleToFit"},
  32.         {"pCDdebug_MaxOverview","0"},
  33.         {"SharpenImage","NO"},
  34.         {NULL,NULL}
  35.         };
  36.     
  37.     // defaults processing
  38.     NXRegisterDefaults([NXApp appName], defs);
  39.  
  40.     globImageSize = is_Base_TAG;
  41.     if ( NXGetDefaultValue([NXApp appName],"OpenImageSize") ) {
  42.         strcpy( tempStr, NXGetDefaultValue([NXApp appName],
  43.                 "OpenImageSize"));
  44.         if ( !strcmp(tempStr, "base/16") ) globImageSize = is_Base16_TAG;
  45.         if ( !strcmp(tempStr, "base/4") )  globImageSize = is_Base4_TAG;
  46.         if ( !strcmp(tempStr, "base") )    globImageSize = is_Base_TAG;
  47.         if ( !strcmp(tempStr, "4base") )   globImageSize = is_4Base_TAG;
  48.         if ( !strcmp(tempStr, "16base") )  globImageSize = is_16Base_TAG;
  49.         }
  50.     
  51.     globImageResolution = 72;
  52.     if ( NXGetDefaultValue([NXApp appName],"OpenImageResolution") ) {
  53.         strcpy( tempStr, NXGetDefaultValue([NXApp appName],
  54.                 "OpenImageResolution"));
  55.         /* probably should just accept this as an integer, but... */
  56.         if ( !strcmp(tempStr,  "72") ) globImageResolution = 72;
  57.         if ( !strcmp(tempStr, "144") ) globImageResolution = 144;
  58.         if ( !strcmp(tempStr, "150") ) globImageResolution = 150;
  59.         if ( !strcmp(tempStr, "180") ) globImageResolution = 180;
  60.         if ( !strcmp(tempStr, "200") ) globImageResolution = 200;
  61.         if ( !strcmp(tempStr, "300") ) globImageResolution = 300;
  62.         if ( !strcmp(tempStr, "360") ) globImageResolution = 360;
  63.         if ( !strcmp(tempStr, "400") ) globImageResolution = 400;
  64.         }
  65.     
  66.     overviewLayoutTag = ov_6x7_TAG;
  67.     if ( NXGetDefaultValue([NXApp appName],"OverviewLayout") ) {
  68.         strcpy( tempStr, NXGetDefaultValue([NXApp appName],
  69.                 "OverviewLayout"));
  70.         if ( ! strcmp(tempStr, "10x2") ) overviewLayoutTag = ov_10x2_TAG;
  71.         if ( ! strcmp(tempStr, "6x7") )  overviewLayoutTag = ov_6x7_TAG;
  72.         if ( ! strcmp(tempStr, "2x12") ) overviewLayoutTag = ov_2x12_TAG;
  73.         }
  74.     [self loadOverviewNib:overviewLayoutTag andSave:NO];
  75.     
  76.     depthPref = NX_TwentyFourBitRGBDepth;
  77.     if ( NXGetDefaultValue([NXApp appName],"OpenImageWindowDepth") ) {
  78.         strcpy( tempStr, NXGetDefaultValue([NXApp appName],
  79.                 "OpenImageWindowDepth"));
  80.         if ( ! strcmp(tempStr, "DefaultDepth") ) 
  81.                         depthPref = NX_DefaultDepth;
  82.         if ( ! strcmp(tempStr, "2_Bit_Grey") ) 
  83.                         depthPref = NX_TwoBitGrayDepth;
  84.         if ( ! strcmp(tempStr, "8_Bit_Grey") ) 
  85.                         depthPref = NX_EightBitGrayDepth;
  86.         if ( ! strcmp(tempStr, "12_Bit_RGB") ) 
  87.                         depthPref = NX_TwelveBitRGBDepth;
  88.         if ( ! strcmp(tempStr, "24_Bit_RGB") ) 
  89.                         depthPref = NX_TwentyFourBitRGBDepth;
  90.         }
  91.     [photoWindow setDepthOfNewWindows:depthPref];
  92.     
  93.     globSharpenImage = NO;
  94.     if ( NXGetDefaultValue([NXApp appName],"SharpenImage") ) {
  95.         strcpy( tempStr, NXGetDefaultValue([NXApp appName],
  96.                 "SharpenImage"));
  97.         if ( ! strcmp(tempStr, "Yes") ) 
  98.                         globSharpenImage = YES;
  99.         if ( ! strcmp(tempStr, "YES") ) 
  100.                         globSharpenImage = YES;
  101.         }
  102.     [pCD_Reader setDoSharp:globSharpenImage];
  103.     
  104.     globNextGamma = YES;
  105.     if ( NXGetDefaultValue([NXApp appName],"GammaCorrection") ) {
  106.         strcpy( tempStr, NXGetDefaultValue([NXApp appName],
  107.                 "GammaCorrection"));
  108.         if ( ! strcmp(tempStr, "2.2") ) 
  109.                         globNextGamma = YES;
  110.         if ( ! strcmp(tempStr, "NeXT") ) 
  111.                         globNextGamma = YES;
  112.         if ( ! strcmp(tempStr, "None") ) 
  113.                         globNextGamma = NO;
  114.         if ( ! strcmp(tempStr, "Linear") ) 
  115.                         globNextGamma = NO;
  116.         }
  117.     [pCD_Reader setNextGammaCorrection:globNextGamma];
  118.     
  119.     printPagination = NX_FITPAGINATION;
  120.     if ( NXGetDefaultValue([NXApp appName],"PrintPagination") ) {
  121.         strcpy( tempStr, NXGetDefaultValue([NXApp appName],
  122.                 "PrintPagination"));
  123.         if ( ! strcmp(tempStr, "SplitAcrossPages") ) 
  124.                         printPagination = NX_AUTOPAGINATION;
  125.         if ( ! strcmp(tempStr, "ScaleToSinglePage") ) 
  126.                         printPagination = NX_FITPAGINATION;
  127.         if ( ! strcmp(tempStr, "ClipToSinglePage") ) 
  128.                         printPagination = NX_CLIPPAGINATION;
  129.         }
  130.  
  131.     //  The following preference is useful when debugging, so the
  132.     //      program only reads part of overview.pcd. 
  133.     overviewReadMax = ovImageMax;
  134.     if ( NXGetDefaultValue([NXApp appName],"pCDdebug_MaxOverview") ) {
  135.         tempInt = atoi( NXGetDefaultValue([NXApp appName],
  136.                 "pCDdebug_MaxOverview"));
  137.         if ((tempInt > 0) && (tempInt < ovImageMax))
  138.                         overviewReadMax = tempInt;
  139.         }
  140.     
  141.     //  should printWhich and saveTo be preferences too?
  142.     printWhich = IMG;
  143.     
  144.     //  Try to make sure each paste operation gets a window
  145.     //     with a unique title.
  146.     pasteCounter = 0;
  147.  
  148.     sp = [SavePanel new];
  149.     [sp setAccessoryView:saveAccessory];
  150.     [sp setRequiredFileType:"tiff"]; saveTo = TIFF;
  151.     
  152.     pp = [PrintPanel new];
  153.     [pp setAccessoryView:printAccessory];
  154.     pInfo = [[PrintInfo alloc] init];
  155.     [pInfo setVertPagination:printPagination];
  156.     [pInfo setHorizPagination:printPagination];
  157.     [NXApp setPrintInfo:pInfo];
  158.     saveTo = TIFF;
  159.  
  160.     // initialize overview panel
  161.     volumeDir = NULL;
  162.     for( ovImageCount=0; ovImageCount < ovImageMax; ovImageCount++ ) {
  163.         ovImageIds[ovImageCount] = nil;
  164.     }
  165.     ovImageCount = 0;
  166.  
  167. // Start out by requesting Photo CD volume.
  168. // For now, ask for the appropriate directory.
  169.  
  170.     [self openPCD:self];
  171.  
  172.     return self;
  173. }
  174.  
  175. - (int)nextPasteCounter
  176. {
  177.     // called from ImageView objects by a rather dubious route...
  178.     
  179.     return ++pasteCounter;
  180. }
  181.  
  182. - showInfoPanel:sender
  183. {
  184.     if ( ! infoPanel )
  185.     infoPanel = [NXApp loadNibSection:"pCD_Info.nib" owner:self];
  186.     [infoPanel makeKeyAndOrderFront:self];
  187.  
  188.     return self;
  189. }
  190.  
  191. - showOverviewWindow:sender
  192. {
  193.     if ( overviewId ) {
  194.         [overviewId showOverview];
  195.     }
  196.     
  197.     return self;
  198. }
  199.  
  200. - showPrefsPanel:sender
  201. {
  202.     int        paginationTag;
  203.     
  204.     paginationTag = ppag_ScaleToSinglePage;
  205.     if ( printPagination == NX_AUTOPAGINATION )
  206.                 paginationTag = ppag_SplitAcrossPages;
  207.     if ( printPagination == NX_CLIPPAGINATION )
  208.                 paginationTag = ppag_ClipToSinglePage;
  209.     [prefsPaginationMatrix selectCellWithTag:paginationTag ];
  210.     
  211.     [prefsResolutionMatrix selectCellWithTag:globImageResolution ];
  212.     [prefsSizeMatrix selectCellWithTag:globImageSize ];
  213.     [prefsLayoutMatrix selectCellWithTag:overviewLayoutTag ];
  214.  
  215.     [prefsSharpenSwitch setState:globSharpenImage ];
  216.     [prefsNGammaSwitch setState:globNextGamma ];
  217.  
  218.     [prefsPanel makeKeyAndOrderFront:self];    
  219.     return self;
  220. }
  221.  
  222. - setPrefImageResolution:sender
  223. {
  224.     char    tempStr[20];
  225.     
  226.     globImageResolution = [sender selectedTag];
  227.     sprintf(tempStr, "%d", globImageResolution);
  228.     NXWriteDefault([NXApp appName], "OpenImageResolution", tempStr);
  229.  
  230.     return self;
  231. }
  232.  
  233. - setPrefImageSize:sender
  234. {
  235.     globImageSize = [sender selectedTag];
  236.     switch ( globImageSize ) {
  237.        case is_Base16_TAG:
  238.         NXWriteDefault([NXApp appName], "OpenImageSize", "base/16");
  239.         break;
  240.        case is_Base4_TAG:  
  241.         NXWriteDefault([NXApp appName], "OpenImageSize", "base/4");
  242.         break;
  243.        case is_4Base_TAG:
  244.         NXWriteDefault([NXApp appName], "OpenImageSize", "4base");
  245.         break;
  246.        case is_16Base_TAG:
  247.         NXWriteDefault([NXApp appName], "OpenImageSize", "16base");
  248.         break;
  249.        default:
  250.         NXWriteDefault([NXApp appName], "OpenImageSize", "base");
  251.         break;
  252.        }
  253.  
  254.     return self;
  255. }
  256.  
  257. - setPrefNextGamma:sender
  258. {
  259.     char    tempStr[20];
  260.     
  261.     globNextGamma = [sender state];
  262.     if ( globNextGamma ) strcpy(tempStr, "NeXT");
  263.     else                 strcpy(tempStr, "Linear");
  264.     NXWriteDefault([NXApp appName], "GammaCorrection", tempStr);
  265.  
  266.     [pCD_Reader setNextGammaCorrection:globNextGamma];
  267.     return self;
  268. }
  269.  
  270. - setPrefOverviewLayout:sender
  271. {
  272.     // if an overview layout is set, close it
  273.     if ( overviewId ) {
  274.     [overviewId closeOverviewPanel:self];
  275.     overviewId = nil;
  276.     }
  277.  
  278.     [self loadOverviewNib:[sender selectedTag] andSave:YES];
  279.     [overviewId setImageArray:&ovImageIds imageCount:ovImageCount];
  280.     [self showOverviewWindow:self];
  281.  
  282.     return self;
  283. }
  284.  
  285. - setPrefPagination:sender
  286. {
  287.     int        pagTag;
  288.     char    strValue[20];
  289.     PrintInfo    *pInfo;
  290.     
  291.     pagTag = [sender selectedTag];
  292.     switch ( pagTag ) {
  293.        case ppag_SplitAcrossPages:
  294.         printPagination = NX_AUTOPAGINATION;
  295.         strcpy(strValue, "SplitAcrossPages");
  296.         break;
  297.        case ppag_ClipToSinglePage:
  298.         printPagination = NX_CLIPPAGINATION;
  299.         strcpy(strValue, "ClipToSinglePage");
  300.         break;
  301.        default:        /* assumed to be ppag_ScaleToSinglePage */
  302.         printPagination = NX_FITPAGINATION;
  303.         strcpy(strValue, "ScaleToSinglePage");
  304.         break;
  305.        }
  306.  
  307.     pInfo = [NXApp printInfo];
  308.     [pInfo setVertPagination:printPagination];
  309.     [pInfo setHorizPagination:printPagination];
  310.     NXWriteDefault([NXApp appName], "PrintPagination", strValue);
  311.     return self;
  312. }
  313.  
  314. - setPrefSharpen:sender
  315. {
  316.     char    tempStr[20];
  317.     
  318.     globSharpenImage = [sender state];
  319.     if ( globSharpenImage ) strcpy(tempStr, "Yes");
  320.     else                    strcpy(tempStr, "No");
  321.     NXWriteDefault([NXApp appName], "SharpenImage", tempStr);
  322.  
  323.     [pCD_Reader setDoSharp:globSharpenImage];
  324.     return self;
  325. }
  326.  
  327. /*  sample:  [self loadOverviewNib:overviewLayoutTag andSave:NO]; */
  328.  
  329. - loadOverviewNib:(enum ov_Tags)overviewTag andSave:(BOOL)saveDefault
  330. {
  331.     char    prefString[10];
  332.     
  333.     overviewLayoutTag = overviewTag;
  334.     
  335.     switch ( overviewLayoutTag ) {
  336.        case ov_10x2_TAG:
  337.         strcpy(prefString, "10x2");
  338.         if ( ! ov_10x2_Id )
  339.         [NXApp loadNibSection:"Overview_10x2.nib" owner:self
  340.                 withNames:YES];
  341.         overviewId = ov_10x2_Id;
  342.         break;
  343.        case ov_2x12_TAG:
  344.         strcpy(prefString, "2x12");
  345.         if ( ! ov_2x12_Id )
  346.         [NXApp loadNibSection:"Overview_2x12.nib" owner:self
  347.                 withNames:YES];
  348.         overviewId = ov_2x12_Id;
  349.         break;
  350.        default:
  351.         strcpy(prefString, "6x7");
  352.         if ( ! ov_6x7_Id )
  353.         [NXApp loadNibSection:"Overview.nib" owner:self
  354.                 withNames:YES];
  355.         overviewId = ov_6x7_Id;
  356.         break;
  357.        }
  358.     
  359.     if ( saveDefault ) {
  360.     NXWriteDefault([NXApp appName], "OverviewLayout", prefString);
  361.     }
  362.     
  363.     return self;
  364. }
  365.  
  366. - openPCD:sender
  367. {
  368.     id        op;
  369.     char    *lastSlash;
  370.     char    *openDir = "/";
  371.     const char    *types[] = {"pcd", NULL};
  372.     
  373.     op = [OpenPanel new];
  374.     [op setPrompt:"Photo CD:"];
  375.     [op setTitle:"Photo CD Volume"];
  376.  
  377.     /* note that really odd things happen if you set chooseDirectories
  378.      * to YES and then the user chooses a file (such as overview.pcd)
  379.     */
  380.     [op chooseDirectories:YES];
  381.     
  382.     if( volumeDir ) openDir = volumeDir;
  383.  
  384.     if( [op runModalForDirectory:openDir file:"" types:types]) {
  385.     if( volumeDir ) free(volumeDir);
  386.     volumeDir = malloc( strlen([op filename]) + 10 + 1 );
  387.     strcpy(volumeDir, [op filename] );
  388.     
  389.     /* crude parsing of the file/directory the user selected,
  390.        which makes things a little nicer for the average user
  391.        who is trying to open up a real photo CD
  392.        
  393.        programming note: In NS3.0, if "chooseDirectories" is YES
  394.        and the user selects a file, then "filename" returned is
  395.        apparently *missing* a directory.  So if the user selects
  396.        "/PCD1909/photo_cd/overview.pcd", then the filename the
  397.        program sees is "/PCD1909/overview.pcd" !!!
  398.        
  399.        The order of the following checks happens to fix that well
  400.        enough for the purposes of this program.  Sounds like a
  401.        pretty weird bug to me though!
  402.     */
  403.     lastSlash = strrchr(volumeDir, '/');
  404.     if ( lastSlash ) {
  405.         if ( ! strcmp(lastSlash, "/overview.pcd") ) {
  406.         *lastSlash = '\0';
  407.         lastSlash = strrchr(volumeDir, '/');
  408.         }
  409.         if ( 0 != strcmp(lastSlash, "/photo_cd") ){
  410.         strcat(volumeDir, "/photo_cd");
  411.         }
  412.         }
  413.  
  414.     if ( [self readOverview] ) {
  415.         [overviewId setImageArray:&ovImageIds imageCount:ovImageCount];
  416.         [self showOverviewWindow:self];
  417.         }
  418.     }
  419.     
  420.     return self;
  421. }
  422.  
  423. - readOverview
  424. {
  425.     char    *ovFil;
  426.  
  427.     ovFil = malloc(strlen(volumeDir) + strlen("/overview.pcd") + 1);
  428.     strcpy(ovFil, volumeDir);
  429.     strcat(ovFil, "/overview.pcd");
  430.     
  431.     ovImageCount = [pCD_Reader readOverviewFromFile:ovFil
  432.             curImageCount:ovImageCount
  433.             ImageArray:&ovImageIds
  434.             MaxEntries:overviewReadMax];
  435.  
  436.     free(ovFil);
  437.     [readStatusPanel close];
  438.  
  439.     return self;
  440. }
  441.  
  442. - showImage:(int)pictNumber atSize:(enum is_Tags)imageSizeWanted
  443.                  atRes:(int)imageResolutionWanted
  444. {
  445.     NXBitmapImageRep  *bm;
  446.     char    *imDir, *title, tmpStr[10];
  447.     char    *imFile = malloc( strlen("/images/imgxxxx.pcd ") +1 );
  448.         
  449.     imDir = malloc(strlen(volumeDir) + malloc_size(imFile) + 1);
  450.     strcpy(imDir, volumeDir);
  451.     strcat(imDir, "/images");
  452.     sprintf(imFile, "/img%04d.pcd", pictNumber );
  453.     strcat(imDir, imFile);
  454.     
  455.     if ( imageSizeWanted == is_GlobalPref_TAG )
  456.                 imageSizeWanted = globImageSize;
  457.     bm = [pCD_Reader readBitmapFromFile:imDir atSize:imageSizeWanted];
  458.  
  459.     //    the window title name will include information on the
  460.     //  image size and resolution.
  461.     title = malloc(strlen(volumeDir) + malloc_size(imFile) + 10);
  462.     strcpy(title, volumeDir);
  463.     sprintf(imFile, "/img%04d.", pictNumber );
  464.     strcat(title, imFile);
  465.  
  466.     switch ( imageSizeWanted ) {
  467.     case is_Base16_TAG:    strcat(title, "base16");  break;
  468.     case is_Base4_TAG:    strcat(title, "base4");  break;
  469.     case is_Base_TAG:    strcat(title, "base"); break;
  470.     case is_4Base_TAG:    strcat(title, "4base"); break;
  471.     case is_16Base_TAG:    strcat(title, "16base"); break;
  472.     default:        strcat(title, "?base?"); break;
  473.     }
  474.  
  475.     if ( imageResolutionWanted == ir_GlobalPref_TAG )
  476.                 imageResolutionWanted = globImageResolution;
  477.     sprintf(tmpStr, "_@%03ddpi", imageResolutionWanted);
  478.     strcat(title, tmpStr);
  479.  
  480.     [photoWindow displayImage:bm withName:title
  481.                  atResolution:imageResolutionWanted];
  482.         
  483.     free(imFile);
  484.     free(imDir);
  485.     return self;
  486. }
  487.  
  488. - changeSaveType:sender
  489. {
  490.     switch ([sender selectedRow]) {
  491.     case 0: [[sender window] setRequiredFileType:"tiff"]; saveTo = TIFF; break;
  492.     case 1: [[sender window] setRequiredFileType:"eps"]; saveTo = EPS; break;
  493.     case 2: [[sender window] setRequiredFileType:"jpg"]; saveTo = JPG; break;
  494.     }
  495.     return self;
  496. }
  497.  
  498. - changePrintType:sender
  499. {
  500.     switch ([sender selectedRow]) {
  501.        case 0: printWhich = IMG; break;
  502.        case 1: printWhich = WIN; break;
  503.     }
  504.     return self;
  505. }
  506.  
  507. - saveTo:sender
  508. {
  509.     NXStream   *st;
  510.     int  status;
  511.     
  512.     if( status = [sp runModalForDirectory:"." file:"Untitled"]) {
  513.        st = NXOpenMemory(NULL, 0, NX_WRITEONLY);
  514.        switch( saveTo ) {
  515.           case TIFF:
  516.              [[[[NXApp mainWindow] contentView] image] writeTIFF:st];
  517.              break;
  518.           case EPS:
  519.              [[[NXApp mainWindow] contentView] copyPSCodeInside:NULL to:st];
  520.              break;
  521.           case JPG:
  522.              [[[[NXApp mainWindow] contentView] image]
  523.                        writeTIFF:st usingCompression:NX_TIFF_COMPRESSION_JPEG];
  524.              break;
  525.        }
  526.        NXSaveToFile(st, [sp filename]);
  527.        NXCloseMemory(st, NX_FREEBUFFER);
  528.     }
  529.     return self;
  530. }
  531.  
  532. - printSel:sender
  533. {
  534.     int exitTag;
  535.     
  536.     exitTag = [pp runModal];
  537.     [pp orderOut:self];
  538.     if( exitTag != NX_CANCELTAG ) {
  539.        [pp finalWritePrintInfo];
  540.        switch ( printWhich ) {
  541.           case IMG:
  542.              [[[NXApp mainWindow] contentView] printPSCode:self];
  543.              break;
  544.           case WIN:
  545.              [[NXApp mainWindow] printPSCode:self];
  546.              break;
  547.        }
  548.     }
  549.     return self;
  550. }
  551.  
  552. - (BOOL)shouldRunPrintPanel:aView
  553. {
  554.     return NO;
  555. }
  556.  
  557. @end
  558.